 /* Copyright 2018 JDCLOUD.COM

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http:#www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

京东云VPC
VPC相关API

OpenAPI spec version: v1
Contact: 

NOTE: This class is auto generated by the jdcloud code generator program.
*/


#import <Foundation/Foundation.h>
#import <JDCloudOCSDKVpc/VpcExecutor.h>

@implementation VpcClient

@synthesize userAgent = _userAgent;
@synthesize serviceName = _serviceName;
@synthesize version = _version;

-(void) addCustomerHeaderWithKey:(NSString*) key
                           value:(NSString*) value{
    if(![self customHeader])
    {
        self.customHeader = [[NSMutableDictionary alloc] init];
    }
    if(key && value)
    {
        [[self customHeader] setValue:value forKey:key];
    }
   
}

-(id)initWithGlobalConfig{
    if(![GlobalConfig credential])
    {
        NSException *e = [SDKArgumentNullException exceptionWithName:@"ArgumentNullException" reason:@"GlobalConfig credential not config" userInfo:nil];
        @throw e;
    }
    self.credential = [GlobalConfig credential];
    if(![GlobalConfig sdkEnvironment])
    {
        self.sdkEnvironment = [[SDKEnvironment alloc] initWithEndPoint:@"vpc.jdcloud-api.com"];
    }else
    {
        self.sdkEnvironment = [GlobalConfig sdkEnvironment];
    }
    self.httpRequestProtocol = @"https";
    _userAgent = @"JdCloudOCSdk 0.0.1 vpc  v1";
    _serviceName = @"vpc";
    _version = @"v1";
    self.contentType = @"application/json";
    return self;
}

-(id)initWithCredential:(Credential*)credential
         sdkEnvironment:(SDKEnvironment*)sdkEnvironment
{
    if(!credential)
    {
        NSException *e = [SDKArgumentNullException exceptionWithName:@"ArgumentNullException" reason:@" credential can not null" userInfo:nil];
        @throw e;
    }else{
        self.credential = credential;
    }
    
    if(!sdkEnvironment)
    {
        NSException *e = [SDKArgumentNullException exceptionWithName:@"ArgumentNullException" reason:@" sdkEnvironment can not null" userInfo:nil];
        @throw e;
    }else{
        self.sdkEnvironment = sdkEnvironment;
    }
    self.httpRequestProtocol = @"https";
    _userAgent = @"JdCloudOCSdk 0.0.1 vpc  v1";
    _serviceName = @"vpc";
    _version = @"v1";
    self.contentType = @"application/json";
    return self;
}

-(id)initWithCredential:(Credential*)credential
{
    if(!credential)
    {
        NSException *e = [SDKArgumentNullException exceptionWithName:@"ArgumentNullException" reason:@" credential can not null" userInfo:nil];
        @throw e;
    }else{
        self.credential = credential;
    }
    if(![GlobalConfig sdkEnvironment])
    {
        self.sdkEnvironment = [[SDKEnvironment alloc] initWithEndPoint:@"vpc.jdcloud-api.com"];
    }else
    {
        self.sdkEnvironment = [GlobalConfig sdkEnvironment];
    }
    self.httpRequestProtocol = @"https";
    _userAgent = @"JdCloudOCSdk 0.0.1 vpc  v1";
    _serviceName = @"vpc";
    _version = @"v1";
    self.contentType = @"application/json";
    return self;
}

-(id)init{
    self.httpRequestProtocol = @"https";
    _userAgent = @"JdCloudOCSdk 0.0.1 vpc  v1";
    _serviceName = @"vpc";
    _version = @"v1";
    self.contentType = @"application/json";
    return self;
}


/**
deleteElasticIp sync request
@param deleteElasticIpRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteElasticIpResponse` the request response data model
*/
-(NSDictionary*) deleteElasticIpSyncWithRequest:(VpcDeleteElasticIpRequest*) deleteElasticIpRequest
{
VpcDeleteElasticIpExecutor* excutor = [[VpcDeleteElasticIpExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteElasticIpRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteElasticIpResponse* response = [[VpcDeleteElasticIpResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteElasticIpResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteElasticIpAsyncWithRequest:(VpcDeleteElasticIpRequest*) deleteElasticIpRequest
                       completionHandler:(void(^)(int statusCode,VpcDeleteElasticIpResponse* _Nullable deleteElasticIpResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDeleteElasticIpExecutor* excutor = [[VpcDeleteElasticIpExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteElasticIpRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteElasticIpResponse* response = [[VpcDeleteElasticIpResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
modifyVpcPeering sync request
@param modifyVpcPeeringRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `modifyVpcPeeringResponse` the request response data model
*/
-(NSDictionary*) modifyVpcPeeringSyncWithRequest:(VpcModifyVpcPeeringRequest*) modifyVpcPeeringRequest
{
VpcModifyVpcPeeringExecutor* excutor = [[VpcModifyVpcPeeringExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:modifyVpcPeeringRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyVpcPeeringResponse* response = [[VpcModifyVpcPeeringResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"modifyVpcPeeringResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)modifyVpcPeeringAsyncWithRequest:(VpcModifyVpcPeeringRequest*) modifyVpcPeeringRequest
                       completionHandler:(void(^)(int statusCode,VpcModifyVpcPeeringResponse* _Nullable modifyVpcPeeringResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcModifyVpcPeeringExecutor* excutor = [[VpcModifyVpcPeeringExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:modifyVpcPeeringRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyVpcPeeringResponse* response = [[VpcModifyVpcPeeringResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
modifyNetworkAclRules sync request
@param modifyNetworkAclRulesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `modifyNetworkAclRulesResponse` the request response data model
*/
-(NSDictionary*) modifyNetworkAclRulesSyncWithRequest:(VpcModifyNetworkAclRulesRequest*) modifyNetworkAclRulesRequest
{
VpcModifyNetworkAclRulesExecutor* excutor = [[VpcModifyNetworkAclRulesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:modifyNetworkAclRulesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyNetworkAclRulesResponse* response = [[VpcModifyNetworkAclRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"modifyNetworkAclRulesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)modifyNetworkAclRulesAsyncWithRequest:(VpcModifyNetworkAclRulesRequest*) modifyNetworkAclRulesRequest
                       completionHandler:(void(^)(int statusCode,VpcModifyNetworkAclRulesResponse* _Nullable modifyNetworkAclRulesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcModifyNetworkAclRulesExecutor* excutor = [[VpcModifyNetworkAclRulesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:modifyNetworkAclRulesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyNetworkAclRulesResponse* response = [[VpcModifyNetworkAclRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
modifyElasticIp sync request
@param modifyElasticIpRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `modifyElasticIpResponse` the request response data model
*/
-(NSDictionary*) modifyElasticIpSyncWithRequest:(VpcModifyElasticIpRequest*) modifyElasticIpRequest
{
VpcModifyElasticIpExecutor* excutor = [[VpcModifyElasticIpExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:modifyElasticIpRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyElasticIpResponse* response = [[VpcModifyElasticIpResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"modifyElasticIpResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)modifyElasticIpAsyncWithRequest:(VpcModifyElasticIpRequest*) modifyElasticIpRequest
                       completionHandler:(void(^)(int statusCode,VpcModifyElasticIpResponse* _Nullable modifyElasticIpResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcModifyElasticIpExecutor* excutor = [[VpcModifyElasticIpExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:modifyElasticIpRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyElasticIpResponse* response = [[VpcModifyElasticIpResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteNetworkAcl sync request
@param deleteNetworkAclRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteNetworkAclResponse` the request response data model
*/
-(NSDictionary*) deleteNetworkAclSyncWithRequest:(VpcDeleteNetworkAclRequest*) deleteNetworkAclRequest
{
VpcDeleteNetworkAclExecutor* excutor = [[VpcDeleteNetworkAclExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteNetworkAclRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteNetworkAclResponse* response = [[VpcDeleteNetworkAclResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteNetworkAclResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteNetworkAclAsyncWithRequest:(VpcDeleteNetworkAclRequest*) deleteNetworkAclRequest
                       completionHandler:(void(^)(int statusCode,VpcDeleteNetworkAclResponse* _Nullable deleteNetworkAclResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDeleteNetworkAclExecutor* excutor = [[VpcDeleteNetworkAclExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteNetworkAclRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteNetworkAclResponse* response = [[VpcDeleteNetworkAclResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteSubnet sync request
@param deleteSubnetRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteSubnetResponse` the request response data model
*/
-(NSDictionary*) deleteSubnetSyncWithRequest:(VpcDeleteSubnetRequest*) deleteSubnetRequest
{
VpcDeleteSubnetExecutor* excutor = [[VpcDeleteSubnetExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteSubnetRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteSubnetResponse* response = [[VpcDeleteSubnetResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteSubnetResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteSubnetAsyncWithRequest:(VpcDeleteSubnetRequest*) deleteSubnetRequest
                       completionHandler:(void(^)(int statusCode,VpcDeleteSubnetResponse* _Nullable deleteSubnetResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDeleteSubnetExecutor* excutor = [[VpcDeleteSubnetExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteSubnetRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteSubnetResponse* response = [[VpcDeleteSubnetResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeSubnets sync request
@param describeSubnetsRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeSubnetsResponse` the request response data model
*/
-(NSDictionary*) describeSubnetsSyncWithRequest:(VpcDescribeSubnetsRequest*) describeSubnetsRequest
{
VpcDescribeSubnetsExecutor* excutor = [[VpcDescribeSubnetsExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeSubnetsRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeSubnetsResponse* response = [[VpcDescribeSubnetsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeSubnetsResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeSubnetsAsyncWithRequest:(VpcDescribeSubnetsRequest*) describeSubnetsRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeSubnetsResponse* _Nullable describeSubnetsResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeSubnetsExecutor* excutor = [[VpcDescribeSubnetsExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeSubnetsRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeSubnetsResponse* response = [[VpcDescribeSubnetsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeNetworkInterfaces sync request
@param describeNetworkInterfacesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeNetworkInterfacesResponse` the request response data model
*/
-(NSDictionary*) describeNetworkInterfacesSyncWithRequest:(VpcDescribeNetworkInterfacesRequest*) describeNetworkInterfacesRequest
{
VpcDescribeNetworkInterfacesExecutor* excutor = [[VpcDescribeNetworkInterfacesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeNetworkInterfacesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeNetworkInterfacesResponse* response = [[VpcDescribeNetworkInterfacesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeNetworkInterfacesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeNetworkInterfacesAsyncWithRequest:(VpcDescribeNetworkInterfacesRequest*) describeNetworkInterfacesRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeNetworkInterfacesResponse* _Nullable describeNetworkInterfacesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeNetworkInterfacesExecutor* excutor = [[VpcDescribeNetworkInterfacesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeNetworkInterfacesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeNetworkInterfacesResponse* response = [[VpcDescribeNetworkInterfacesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
removeNetworkSecurityGroupRules sync request
@param removeNetworkSecurityGroupRulesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `removeNetworkSecurityGroupRulesResponse` the request response data model
*/
-(NSDictionary*) removeNetworkSecurityGroupRulesSyncWithRequest:(VpcRemoveNetworkSecurityGroupRulesRequest*) removeNetworkSecurityGroupRulesRequest
{
VpcRemoveNetworkSecurityGroupRulesExecutor* excutor = [[VpcRemoveNetworkSecurityGroupRulesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:removeNetworkSecurityGroupRulesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcRemoveNetworkSecurityGroupRulesResponse* response = [[VpcRemoveNetworkSecurityGroupRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"removeNetworkSecurityGroupRulesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)removeNetworkSecurityGroupRulesAsyncWithRequest:(VpcRemoveNetworkSecurityGroupRulesRequest*) removeNetworkSecurityGroupRulesRequest
                       completionHandler:(void(^)(int statusCode,VpcRemoveNetworkSecurityGroupRulesResponse* _Nullable removeNetworkSecurityGroupRulesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcRemoveNetworkSecurityGroupRulesExecutor* excutor = [[VpcRemoveNetworkSecurityGroupRulesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:removeNetworkSecurityGroupRulesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcRemoveNetworkSecurityGroupRulesResponse* response = [[VpcRemoveNetworkSecurityGroupRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
modifyNetworkSecurityGroup sync request
@param modifyNetworkSecurityGroupRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `modifyNetworkSecurityGroupResponse` the request response data model
*/
-(NSDictionary*) modifyNetworkSecurityGroupSyncWithRequest:(VpcModifyNetworkSecurityGroupRequest*) modifyNetworkSecurityGroupRequest
{
VpcModifyNetworkSecurityGroupExecutor* excutor = [[VpcModifyNetworkSecurityGroupExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:modifyNetworkSecurityGroupRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyNetworkSecurityGroupResponse* response = [[VpcModifyNetworkSecurityGroupResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"modifyNetworkSecurityGroupResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)modifyNetworkSecurityGroupAsyncWithRequest:(VpcModifyNetworkSecurityGroupRequest*) modifyNetworkSecurityGroupRequest
                       completionHandler:(void(^)(int statusCode,VpcModifyNetworkSecurityGroupResponse* _Nullable modifyNetworkSecurityGroupResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcModifyNetworkSecurityGroupExecutor* excutor = [[VpcModifyNetworkSecurityGroupExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:modifyNetworkSecurityGroupRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyNetworkSecurityGroupResponse* response = [[VpcModifyNetworkSecurityGroupResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
addNetworkSecurityGroupRules sync request
@param addNetworkSecurityGroupRulesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `addNetworkSecurityGroupRulesResponse` the request response data model
*/
-(NSDictionary*) addNetworkSecurityGroupRulesSyncWithRequest:(VpcAddNetworkSecurityGroupRulesRequest*) addNetworkSecurityGroupRulesRequest
{
VpcAddNetworkSecurityGroupRulesExecutor* excutor = [[VpcAddNetworkSecurityGroupRulesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:addNetworkSecurityGroupRulesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAddNetworkSecurityGroupRulesResponse* response = [[VpcAddNetworkSecurityGroupRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"addNetworkSecurityGroupRulesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)addNetworkSecurityGroupRulesAsyncWithRequest:(VpcAddNetworkSecurityGroupRulesRequest*) addNetworkSecurityGroupRulesRequest
                       completionHandler:(void(^)(int statusCode,VpcAddNetworkSecurityGroupRulesResponse* _Nullable addNetworkSecurityGroupRulesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcAddNetworkSecurityGroupRulesExecutor* excutor = [[VpcAddNetworkSecurityGroupRulesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:addNetworkSecurityGroupRulesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAddNetworkSecurityGroupRulesResponse* response = [[VpcAddNetworkSecurityGroupRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createNetworkAcl sync request
@param createNetworkAclRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createNetworkAclResponse` the request response data model
*/
-(NSDictionary*) createNetworkAclSyncWithRequest:(VpcCreateNetworkAclRequest*) createNetworkAclRequest
{
VpcCreateNetworkAclExecutor* excutor = [[VpcCreateNetworkAclExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createNetworkAclRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateNetworkAclResponse* response = [[VpcCreateNetworkAclResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createNetworkAclResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createNetworkAclAsyncWithRequest:(VpcCreateNetworkAclRequest*) createNetworkAclRequest
                       completionHandler:(void(^)(int statusCode,VpcCreateNetworkAclResponse* _Nullable createNetworkAclResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcCreateNetworkAclExecutor* excutor = [[VpcCreateNetworkAclExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createNetworkAclRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateNetworkAclResponse* response = [[VpcCreateNetworkAclResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeQuota sync request
@param describeQuotaRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeQuotaResponse` the request response data model
*/
-(NSDictionary*) describeQuotaSyncWithRequest:(VpcDescribeQuotaRequest*) describeQuotaRequest
{
VpcDescribeQuotaExecutor* excutor = [[VpcDescribeQuotaExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeQuotaRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeQuotaResponse* response = [[VpcDescribeQuotaResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeQuotaResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeQuotaAsyncWithRequest:(VpcDescribeQuotaRequest*) describeQuotaRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeQuotaResponse* _Nullable describeQuotaResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeQuotaExecutor* excutor = [[VpcDescribeQuotaExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeQuotaRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeQuotaResponse* response = [[VpcDescribeQuotaResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createRouteTable sync request
@param createRouteTableRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createRouteTableResponse` the request response data model
*/
-(NSDictionary*) createRouteTableSyncWithRequest:(VpcCreateRouteTableRequest*) createRouteTableRequest
{
VpcCreateRouteTableExecutor* excutor = [[VpcCreateRouteTableExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createRouteTableRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateRouteTableResponse* response = [[VpcCreateRouteTableResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createRouteTableResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createRouteTableAsyncWithRequest:(VpcCreateRouteTableRequest*) createRouteTableRequest
                       completionHandler:(void(^)(int statusCode,VpcCreateRouteTableResponse* _Nullable createRouteTableResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcCreateRouteTableExecutor* excutor = [[VpcCreateRouteTableExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createRouteTableRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateRouteTableResponse* response = [[VpcCreateRouteTableResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeRouteTable sync request
@param describeRouteTableRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeRouteTableResponse` the request response data model
*/
-(NSDictionary*) describeRouteTableSyncWithRequest:(VpcDescribeRouteTableRequest*) describeRouteTableRequest
{
VpcDescribeRouteTableExecutor* excutor = [[VpcDescribeRouteTableExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeRouteTableRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeRouteTableResponse* response = [[VpcDescribeRouteTableResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeRouteTableResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeRouteTableAsyncWithRequest:(VpcDescribeRouteTableRequest*) describeRouteTableRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeRouteTableResponse* _Nullable describeRouteTableResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeRouteTableExecutor* excutor = [[VpcDescribeRouteTableExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeRouteTableRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeRouteTableResponse* response = [[VpcDescribeRouteTableResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteNetworkSecurityGroup sync request
@param deleteNetworkSecurityGroupRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteNetworkSecurityGroupResponse` the request response data model
*/
-(NSDictionary*) deleteNetworkSecurityGroupSyncWithRequest:(VpcDeleteNetworkSecurityGroupRequest*) deleteNetworkSecurityGroupRequest
{
VpcDeleteNetworkSecurityGroupExecutor* excutor = [[VpcDeleteNetworkSecurityGroupExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteNetworkSecurityGroupRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteNetworkSecurityGroupResponse* response = [[VpcDeleteNetworkSecurityGroupResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteNetworkSecurityGroupResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteNetworkSecurityGroupAsyncWithRequest:(VpcDeleteNetworkSecurityGroupRequest*) deleteNetworkSecurityGroupRequest
                       completionHandler:(void(^)(int statusCode,VpcDeleteNetworkSecurityGroupResponse* _Nullable deleteNetworkSecurityGroupResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDeleteNetworkSecurityGroupExecutor* excutor = [[VpcDeleteNetworkSecurityGroupExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteNetworkSecurityGroupRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteNetworkSecurityGroupResponse* response = [[VpcDeleteNetworkSecurityGroupResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeVpcPeerings sync request
@param describeVpcPeeringsRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeVpcPeeringsResponse` the request response data model
*/
-(NSDictionary*) describeVpcPeeringsSyncWithRequest:(VpcDescribeVpcPeeringsRequest*) describeVpcPeeringsRequest
{
VpcDescribeVpcPeeringsExecutor* excutor = [[VpcDescribeVpcPeeringsExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeVpcPeeringsRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeVpcPeeringsResponse* response = [[VpcDescribeVpcPeeringsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeVpcPeeringsResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeVpcPeeringsAsyncWithRequest:(VpcDescribeVpcPeeringsRequest*) describeVpcPeeringsRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeVpcPeeringsResponse* _Nullable describeVpcPeeringsResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeVpcPeeringsExecutor* excutor = [[VpcDescribeVpcPeeringsExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeVpcPeeringsRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeVpcPeeringsResponse* response = [[VpcDescribeVpcPeeringsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteVpc sync request
@param deleteVpcRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteVpcResponse` the request response data model
*/
-(NSDictionary*) deleteVpcSyncWithRequest:(VpcDeleteVpcRequest*) deleteVpcRequest
{
VpcDeleteVpcExecutor* excutor = [[VpcDeleteVpcExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteVpcRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteVpcResponse* response = [[VpcDeleteVpcResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteVpcResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteVpcAsyncWithRequest:(VpcDeleteVpcRequest*) deleteVpcRequest
                       completionHandler:(void(^)(int statusCode,VpcDeleteVpcResponse* _Nullable deleteVpcResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDeleteVpcExecutor* excutor = [[VpcDeleteVpcExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteVpcRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteVpcResponse* response = [[VpcDeleteVpcResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeNetworkAcls sync request
@param describeNetworkAclsRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeNetworkAclsResponse` the request response data model
*/
-(NSDictionary*) describeNetworkAclsSyncWithRequest:(VpcDescribeNetworkAclsRequest*) describeNetworkAclsRequest
{
VpcDescribeNetworkAclsExecutor* excutor = [[VpcDescribeNetworkAclsExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeNetworkAclsRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeNetworkAclsResponse* response = [[VpcDescribeNetworkAclsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeNetworkAclsResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeNetworkAclsAsyncWithRequest:(VpcDescribeNetworkAclsRequest*) describeNetworkAclsRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeNetworkAclsResponse* _Nullable describeNetworkAclsResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeNetworkAclsExecutor* excutor = [[VpcDescribeNetworkAclsExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeNetworkAclsRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeNetworkAclsResponse* response = [[VpcDescribeNetworkAclsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeSubnet sync request
@param describeSubnetRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeSubnetResponse` the request response data model
*/
-(NSDictionary*) describeSubnetSyncWithRequest:(VpcDescribeSubnetRequest*) describeSubnetRequest
{
VpcDescribeSubnetExecutor* excutor = [[VpcDescribeSubnetExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeSubnetRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeSubnetResponse* response = [[VpcDescribeSubnetResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeSubnetResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeSubnetAsyncWithRequest:(VpcDescribeSubnetRequest*) describeSubnetRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeSubnetResponse* _Nullable describeSubnetResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeSubnetExecutor* excutor = [[VpcDescribeSubnetExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeSubnetRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeSubnetResponse* response = [[VpcDescribeSubnetResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeNetworkSecurityGroup sync request
@param describeNetworkSecurityGroupRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeNetworkSecurityGroupResponse` the request response data model
*/
-(NSDictionary*) describeNetworkSecurityGroupSyncWithRequest:(VpcDescribeNetworkSecurityGroupRequest*) describeNetworkSecurityGroupRequest
{
VpcDescribeNetworkSecurityGroupExecutor* excutor = [[VpcDescribeNetworkSecurityGroupExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeNetworkSecurityGroupRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeNetworkSecurityGroupResponse* response = [[VpcDescribeNetworkSecurityGroupResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeNetworkSecurityGroupResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeNetworkSecurityGroupAsyncWithRequest:(VpcDescribeNetworkSecurityGroupRequest*) describeNetworkSecurityGroupRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeNetworkSecurityGroupResponse* _Nullable describeNetworkSecurityGroupResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeNetworkSecurityGroupExecutor* excutor = [[VpcDescribeNetworkSecurityGroupExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeNetworkSecurityGroupRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeNetworkSecurityGroupResponse* response = [[VpcDescribeNetworkSecurityGroupResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeNetworkSecurityGroups sync request
@param describeNetworkSecurityGroupsRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeNetworkSecurityGroupsResponse` the request response data model
*/
-(NSDictionary*) describeNetworkSecurityGroupsSyncWithRequest:(VpcDescribeNetworkSecurityGroupsRequest*) describeNetworkSecurityGroupsRequest
{
VpcDescribeNetworkSecurityGroupsExecutor* excutor = [[VpcDescribeNetworkSecurityGroupsExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeNetworkSecurityGroupsRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeNetworkSecurityGroupsResponse* response = [[VpcDescribeNetworkSecurityGroupsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeNetworkSecurityGroupsResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeNetworkSecurityGroupsAsyncWithRequest:(VpcDescribeNetworkSecurityGroupsRequest*) describeNetworkSecurityGroupsRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeNetworkSecurityGroupsResponse* _Nullable describeNetworkSecurityGroupsResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeNetworkSecurityGroupsExecutor* excutor = [[VpcDescribeNetworkSecurityGroupsExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeNetworkSecurityGroupsRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeNetworkSecurityGroupsResponse* response = [[VpcDescribeNetworkSecurityGroupsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeVpc sync request
@param describeVpcRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeVpcResponse` the request response data model
*/
-(NSDictionary*) describeVpcSyncWithRequest:(VpcDescribeVpcRequest*) describeVpcRequest
{
VpcDescribeVpcExecutor* excutor = [[VpcDescribeVpcExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeVpcRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeVpcResponse* response = [[VpcDescribeVpcResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeVpcResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeVpcAsyncWithRequest:(VpcDescribeVpcRequest*) describeVpcRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeVpcResponse* _Nullable describeVpcResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeVpcExecutor* excutor = [[VpcDescribeVpcExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeVpcRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeVpcResponse* response = [[VpcDescribeVpcResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
disassociateNetworkAcl sync request
@param disassociateNetworkAclRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `disassociateNetworkAclResponse` the request response data model
*/
-(NSDictionary*) disassociateNetworkAclSyncWithRequest:(VpcDisassociateNetworkAclRequest*) disassociateNetworkAclRequest
{
VpcDisassociateNetworkAclExecutor* excutor = [[VpcDisassociateNetworkAclExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:disassociateNetworkAclRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDisassociateNetworkAclResponse* response = [[VpcDisassociateNetworkAclResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"disassociateNetworkAclResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)disassociateNetworkAclAsyncWithRequest:(VpcDisassociateNetworkAclRequest*) disassociateNetworkAclRequest
                       completionHandler:(void(^)(int statusCode,VpcDisassociateNetworkAclResponse* _Nullable disassociateNetworkAclResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDisassociateNetworkAclExecutor* excutor = [[VpcDisassociateNetworkAclExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:disassociateNetworkAclRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDisassociateNetworkAclResponse* response = [[VpcDisassociateNetworkAclResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
removeNetworkAclRules sync request
@param removeNetworkAclRulesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `removeNetworkAclRulesResponse` the request response data model
*/
-(NSDictionary*) removeNetworkAclRulesSyncWithRequest:(VpcRemoveNetworkAclRulesRequest*) removeNetworkAclRulesRequest
{
VpcRemoveNetworkAclRulesExecutor* excutor = [[VpcRemoveNetworkAclRulesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:removeNetworkAclRulesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcRemoveNetworkAclRulesResponse* response = [[VpcRemoveNetworkAclRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"removeNetworkAclRulesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)removeNetworkAclRulesAsyncWithRequest:(VpcRemoveNetworkAclRulesRequest*) removeNetworkAclRulesRequest
                       completionHandler:(void(^)(int statusCode,VpcRemoveNetworkAclRulesResponse* _Nullable removeNetworkAclRulesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcRemoveNetworkAclRulesExecutor* excutor = [[VpcRemoveNetworkAclRulesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:removeNetworkAclRulesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcRemoveNetworkAclRulesResponse* response = [[VpcRemoveNetworkAclRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
associateRouteTable sync request
@param associateRouteTableRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `associateRouteTableResponse` the request response data model
*/
-(NSDictionary*) associateRouteTableSyncWithRequest:(VpcAssociateRouteTableRequest*) associateRouteTableRequest
{
VpcAssociateRouteTableExecutor* excutor = [[VpcAssociateRouteTableExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:associateRouteTableRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAssociateRouteTableResponse* response = [[VpcAssociateRouteTableResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"associateRouteTableResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)associateRouteTableAsyncWithRequest:(VpcAssociateRouteTableRequest*) associateRouteTableRequest
                       completionHandler:(void(^)(int statusCode,VpcAssociateRouteTableResponse* _Nullable associateRouteTableResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcAssociateRouteTableExecutor* excutor = [[VpcAssociateRouteTableExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:associateRouteTableRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAssociateRouteTableResponse* response = [[VpcAssociateRouteTableResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeVpcs sync request
@param describeVpcsRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeVpcsResponse` the request response data model
*/
-(NSDictionary*) describeVpcsSyncWithRequest:(VpcDescribeVpcsRequest*) describeVpcsRequest
{
VpcDescribeVpcsExecutor* excutor = [[VpcDescribeVpcsExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeVpcsRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeVpcsResponse* response = [[VpcDescribeVpcsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeVpcsResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeVpcsAsyncWithRequest:(VpcDescribeVpcsRequest*) describeVpcsRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeVpcsResponse* _Nullable describeVpcsResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeVpcsExecutor* excutor = [[VpcDescribeVpcsExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeVpcsRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeVpcsResponse* response = [[VpcDescribeVpcsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createNetworkSecurityGroup sync request
@param createNetworkSecurityGroupRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createNetworkSecurityGroupResponse` the request response data model
*/
-(NSDictionary*) createNetworkSecurityGroupSyncWithRequest:(VpcCreateNetworkSecurityGroupRequest*) createNetworkSecurityGroupRequest
{
VpcCreateNetworkSecurityGroupExecutor* excutor = [[VpcCreateNetworkSecurityGroupExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createNetworkSecurityGroupRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateNetworkSecurityGroupResponse* response = [[VpcCreateNetworkSecurityGroupResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createNetworkSecurityGroupResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createNetworkSecurityGroupAsyncWithRequest:(VpcCreateNetworkSecurityGroupRequest*) createNetworkSecurityGroupRequest
                       completionHandler:(void(^)(int statusCode,VpcCreateNetworkSecurityGroupResponse* _Nullable createNetworkSecurityGroupResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcCreateNetworkSecurityGroupExecutor* excutor = [[VpcCreateNetworkSecurityGroupExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createNetworkSecurityGroupRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateNetworkSecurityGroupResponse* response = [[VpcCreateNetworkSecurityGroupResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createSubnet sync request
@param createSubnetRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createSubnetResponse` the request response data model
*/
-(NSDictionary*) createSubnetSyncWithRequest:(VpcCreateSubnetRequest*) createSubnetRequest
{
VpcCreateSubnetExecutor* excutor = [[VpcCreateSubnetExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createSubnetRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateSubnetResponse* response = [[VpcCreateSubnetResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createSubnetResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createSubnetAsyncWithRequest:(VpcCreateSubnetRequest*) createSubnetRequest
                       completionHandler:(void(^)(int statusCode,VpcCreateSubnetResponse* _Nullable createSubnetResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcCreateSubnetExecutor* excutor = [[VpcCreateSubnetExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createSubnetRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateSubnetResponse* response = [[VpcCreateSubnetResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteRouteTable sync request
@param deleteRouteTableRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteRouteTableResponse` the request response data model
*/
-(NSDictionary*) deleteRouteTableSyncWithRequest:(VpcDeleteRouteTableRequest*) deleteRouteTableRequest
{
VpcDeleteRouteTableExecutor* excutor = [[VpcDeleteRouteTableExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteRouteTableRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteRouteTableResponse* response = [[VpcDeleteRouteTableResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteRouteTableResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteRouteTableAsyncWithRequest:(VpcDeleteRouteTableRequest*) deleteRouteTableRequest
                       completionHandler:(void(^)(int statusCode,VpcDeleteRouteTableResponse* _Nullable deleteRouteTableResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDeleteRouteTableExecutor* excutor = [[VpcDeleteRouteTableExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteRouteTableRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteRouteTableResponse* response = [[VpcDeleteRouteTableResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeVpcPeering sync request
@param describeVpcPeeringRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeVpcPeeringResponse` the request response data model
*/
-(NSDictionary*) describeVpcPeeringSyncWithRequest:(VpcDescribeVpcPeeringRequest*) describeVpcPeeringRequest
{
VpcDescribeVpcPeeringExecutor* excutor = [[VpcDescribeVpcPeeringExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeVpcPeeringRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeVpcPeeringResponse* response = [[VpcDescribeVpcPeeringResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeVpcPeeringResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeVpcPeeringAsyncWithRequest:(VpcDescribeVpcPeeringRequest*) describeVpcPeeringRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeVpcPeeringResponse* _Nullable describeVpcPeeringResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeVpcPeeringExecutor* excutor = [[VpcDescribeVpcPeeringExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeVpcPeeringRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeVpcPeeringResponse* response = [[VpcDescribeVpcPeeringResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
removeRouteTableRules sync request
@param removeRouteTableRulesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `removeRouteTableRulesResponse` the request response data model
*/
-(NSDictionary*) removeRouteTableRulesSyncWithRequest:(VpcRemoveRouteTableRulesRequest*) removeRouteTableRulesRequest
{
VpcRemoveRouteTableRulesExecutor* excutor = [[VpcRemoveRouteTableRulesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:removeRouteTableRulesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcRemoveRouteTableRulesResponse* response = [[VpcRemoveRouteTableRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"removeRouteTableRulesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)removeRouteTableRulesAsyncWithRequest:(VpcRemoveRouteTableRulesRequest*) removeRouteTableRulesRequest
                       completionHandler:(void(^)(int statusCode,VpcRemoveRouteTableRulesResponse* _Nullable removeRouteTableRulesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcRemoveRouteTableRulesExecutor* excutor = [[VpcRemoveRouteTableRulesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:removeRouteTableRulesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcRemoveRouteTableRulesResponse* response = [[VpcRemoveRouteTableRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createVpcPeering sync request
@param createVpcPeeringRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createVpcPeeringResponse` the request response data model
*/
-(NSDictionary*) createVpcPeeringSyncWithRequest:(VpcCreateVpcPeeringRequest*) createVpcPeeringRequest
{
VpcCreateVpcPeeringExecutor* excutor = [[VpcCreateVpcPeeringExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createVpcPeeringRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateVpcPeeringResponse* response = [[VpcCreateVpcPeeringResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createVpcPeeringResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createVpcPeeringAsyncWithRequest:(VpcCreateVpcPeeringRequest*) createVpcPeeringRequest
                       completionHandler:(void(^)(int statusCode,VpcCreateVpcPeeringResponse* _Nullable createVpcPeeringResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcCreateVpcPeeringExecutor* excutor = [[VpcCreateVpcPeeringExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createVpcPeeringRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateVpcPeeringResponse* response = [[VpcCreateVpcPeeringResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeRouteTables sync request
@param describeRouteTablesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeRouteTablesResponse` the request response data model
*/
-(NSDictionary*) describeRouteTablesSyncWithRequest:(VpcDescribeRouteTablesRequest*) describeRouteTablesRequest
{
VpcDescribeRouteTablesExecutor* excutor = [[VpcDescribeRouteTablesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeRouteTablesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeRouteTablesResponse* response = [[VpcDescribeRouteTablesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeRouteTablesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeRouteTablesAsyncWithRequest:(VpcDescribeRouteTablesRequest*) describeRouteTablesRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeRouteTablesResponse* _Nullable describeRouteTablesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeRouteTablesExecutor* excutor = [[VpcDescribeRouteTablesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeRouteTablesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeRouteTablesResponse* response = [[VpcDescribeRouteTablesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
assignSecondaryIps sync request
@param assignSecondaryIpsRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `assignSecondaryIpsResponse` the request response data model
*/
-(NSDictionary*) assignSecondaryIpsSyncWithRequest:(VpcAssignSecondaryIpsRequest*) assignSecondaryIpsRequest
{
VpcAssignSecondaryIpsExecutor* excutor = [[VpcAssignSecondaryIpsExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:assignSecondaryIpsRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAssignSecondaryIpsResponse* response = [[VpcAssignSecondaryIpsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"assignSecondaryIpsResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)assignSecondaryIpsAsyncWithRequest:(VpcAssignSecondaryIpsRequest*) assignSecondaryIpsRequest
                       completionHandler:(void(^)(int statusCode,VpcAssignSecondaryIpsResponse* _Nullable assignSecondaryIpsResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcAssignSecondaryIpsExecutor* excutor = [[VpcAssignSecondaryIpsExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:assignSecondaryIpsRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAssignSecondaryIpsResponse* response = [[VpcAssignSecondaryIpsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
modifyNetworkInterface sync request
@param modifyNetworkInterfaceRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `modifyNetworkInterfaceResponse` the request response data model
*/
-(NSDictionary*) modifyNetworkInterfaceSyncWithRequest:(VpcModifyNetworkInterfaceRequest*) modifyNetworkInterfaceRequest
{
VpcModifyNetworkInterfaceExecutor* excutor = [[VpcModifyNetworkInterfaceExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:modifyNetworkInterfaceRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyNetworkInterfaceResponse* response = [[VpcModifyNetworkInterfaceResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"modifyNetworkInterfaceResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)modifyNetworkInterfaceAsyncWithRequest:(VpcModifyNetworkInterfaceRequest*) modifyNetworkInterfaceRequest
                       completionHandler:(void(^)(int statusCode,VpcModifyNetworkInterfaceResponse* _Nullable modifyNetworkInterfaceResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcModifyNetworkInterfaceExecutor* excutor = [[VpcModifyNetworkInterfaceExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:modifyNetworkInterfaceRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyNetworkInterfaceResponse* response = [[VpcModifyNetworkInterfaceResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
modifyNetworkSecurityGroupRules sync request
@param modifyNetworkSecurityGroupRulesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `modifyNetworkSecurityGroupRulesResponse` the request response data model
*/
-(NSDictionary*) modifyNetworkSecurityGroupRulesSyncWithRequest:(VpcModifyNetworkSecurityGroupRulesRequest*) modifyNetworkSecurityGroupRulesRequest
{
VpcModifyNetworkSecurityGroupRulesExecutor* excutor = [[VpcModifyNetworkSecurityGroupRulesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:modifyNetworkSecurityGroupRulesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyNetworkSecurityGroupRulesResponse* response = [[VpcModifyNetworkSecurityGroupRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"modifyNetworkSecurityGroupRulesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)modifyNetworkSecurityGroupRulesAsyncWithRequest:(VpcModifyNetworkSecurityGroupRulesRequest*) modifyNetworkSecurityGroupRulesRequest
                       completionHandler:(void(^)(int statusCode,VpcModifyNetworkSecurityGroupRulesResponse* _Nullable modifyNetworkSecurityGroupRulesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcModifyNetworkSecurityGroupRulesExecutor* excutor = [[VpcModifyNetworkSecurityGroupRulesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:modifyNetworkSecurityGroupRulesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyNetworkSecurityGroupRulesResponse* response = [[VpcModifyNetworkSecurityGroupRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeElasticIps sync request
@param describeElasticIpsRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeElasticIpsResponse` the request response data model
*/
-(NSDictionary*) describeElasticIpsSyncWithRequest:(VpcDescribeElasticIpsRequest*) describeElasticIpsRequest
{
VpcDescribeElasticIpsExecutor* excutor = [[VpcDescribeElasticIpsExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeElasticIpsRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeElasticIpsResponse* response = [[VpcDescribeElasticIpsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeElasticIpsResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeElasticIpsAsyncWithRequest:(VpcDescribeElasticIpsRequest*) describeElasticIpsRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeElasticIpsResponse* _Nullable describeElasticIpsResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeElasticIpsExecutor* excutor = [[VpcDescribeElasticIpsExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeElasticIpsRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeElasticIpsResponse* response = [[VpcDescribeElasticIpsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeNetworkInterface sync request
@param describeNetworkInterfaceRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeNetworkInterfaceResponse` the request response data model
*/
-(NSDictionary*) describeNetworkInterfaceSyncWithRequest:(VpcDescribeNetworkInterfaceRequest*) describeNetworkInterfaceRequest
{
VpcDescribeNetworkInterfaceExecutor* excutor = [[VpcDescribeNetworkInterfaceExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeNetworkInterfaceRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeNetworkInterfaceResponse* response = [[VpcDescribeNetworkInterfaceResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeNetworkInterfaceResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeNetworkInterfaceAsyncWithRequest:(VpcDescribeNetworkInterfaceRequest*) describeNetworkInterfaceRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeNetworkInterfaceResponse* _Nullable describeNetworkInterfaceResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeNetworkInterfaceExecutor* excutor = [[VpcDescribeNetworkInterfaceExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeNetworkInterfaceRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeNetworkInterfaceResponse* response = [[VpcDescribeNetworkInterfaceResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
modifyNetworkAcl sync request
@param modifyNetworkAclRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `modifyNetworkAclResponse` the request response data model
*/
-(NSDictionary*) modifyNetworkAclSyncWithRequest:(VpcModifyNetworkAclRequest*) modifyNetworkAclRequest
{
VpcModifyNetworkAclExecutor* excutor = [[VpcModifyNetworkAclExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:modifyNetworkAclRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyNetworkAclResponse* response = [[VpcModifyNetworkAclResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"modifyNetworkAclResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)modifyNetworkAclAsyncWithRequest:(VpcModifyNetworkAclRequest*) modifyNetworkAclRequest
                       completionHandler:(void(^)(int statusCode,VpcModifyNetworkAclResponse* _Nullable modifyNetworkAclResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcModifyNetworkAclExecutor* excutor = [[VpcModifyNetworkAclExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:modifyNetworkAclRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyNetworkAclResponse* response = [[VpcModifyNetworkAclResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
disassociateElasticIp sync request
@param disassociateElasticIpRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `disassociateElasticIpResponse` the request response data model
*/
-(NSDictionary*) disassociateElasticIpSyncWithRequest:(VpcDisassociateElasticIpRequest*) disassociateElasticIpRequest
{
VpcDisassociateElasticIpExecutor* excutor = [[VpcDisassociateElasticIpExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:disassociateElasticIpRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDisassociateElasticIpResponse* response = [[VpcDisassociateElasticIpResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"disassociateElasticIpResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)disassociateElasticIpAsyncWithRequest:(VpcDisassociateElasticIpRequest*) disassociateElasticIpRequest
                       completionHandler:(void(^)(int statusCode,VpcDisassociateElasticIpResponse* _Nullable disassociateElasticIpResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDisassociateElasticIpExecutor* excutor = [[VpcDisassociateElasticIpExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:disassociateElasticIpRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDisassociateElasticIpResponse* response = [[VpcDisassociateElasticIpResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteVpcPeering sync request
@param deleteVpcPeeringRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteVpcPeeringResponse` the request response data model
*/
-(NSDictionary*) deleteVpcPeeringSyncWithRequest:(VpcDeleteVpcPeeringRequest*) deleteVpcPeeringRequest
{
VpcDeleteVpcPeeringExecutor* excutor = [[VpcDeleteVpcPeeringExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteVpcPeeringRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteVpcPeeringResponse* response = [[VpcDeleteVpcPeeringResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteVpcPeeringResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteVpcPeeringAsyncWithRequest:(VpcDeleteVpcPeeringRequest*) deleteVpcPeeringRequest
                       completionHandler:(void(^)(int statusCode,VpcDeleteVpcPeeringResponse* _Nullable deleteVpcPeeringResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDeleteVpcPeeringExecutor* excutor = [[VpcDeleteVpcPeeringExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteVpcPeeringRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteVpcPeeringResponse* response = [[VpcDeleteVpcPeeringResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createNetworkInterface sync request
@param createNetworkInterfaceRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createNetworkInterfaceResponse` the request response data model
*/
-(NSDictionary*) createNetworkInterfaceSyncWithRequest:(VpcCreateNetworkInterfaceRequest*) createNetworkInterfaceRequest
{
VpcCreateNetworkInterfaceExecutor* excutor = [[VpcCreateNetworkInterfaceExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createNetworkInterfaceRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateNetworkInterfaceResponse* response = [[VpcCreateNetworkInterfaceResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createNetworkInterfaceResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createNetworkInterfaceAsyncWithRequest:(VpcCreateNetworkInterfaceRequest*) createNetworkInterfaceRequest
                       completionHandler:(void(^)(int statusCode,VpcCreateNetworkInterfaceResponse* _Nullable createNetworkInterfaceResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcCreateNetworkInterfaceExecutor* excutor = [[VpcCreateNetworkInterfaceExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createNetworkInterfaceRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateNetworkInterfaceResponse* response = [[VpcCreateNetworkInterfaceResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createVpc sync request
@param createVpcRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createVpcResponse` the request response data model
*/
-(NSDictionary*) createVpcSyncWithRequest:(VpcCreateVpcRequest*) createVpcRequest
{
VpcCreateVpcExecutor* excutor = [[VpcCreateVpcExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createVpcRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateVpcResponse* response = [[VpcCreateVpcResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createVpcResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createVpcAsyncWithRequest:(VpcCreateVpcRequest*) createVpcRequest
                       completionHandler:(void(^)(int statusCode,VpcCreateVpcResponse* _Nullable createVpcResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcCreateVpcExecutor* excutor = [[VpcCreateVpcExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createVpcRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateVpcResponse* response = [[VpcCreateVpcResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
modifyRouteTableRules sync request
@param modifyRouteTableRulesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `modifyRouteTableRulesResponse` the request response data model
*/
-(NSDictionary*) modifyRouteTableRulesSyncWithRequest:(VpcModifyRouteTableRulesRequest*) modifyRouteTableRulesRequest
{
VpcModifyRouteTableRulesExecutor* excutor = [[VpcModifyRouteTableRulesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:modifyRouteTableRulesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyRouteTableRulesResponse* response = [[VpcModifyRouteTableRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"modifyRouteTableRulesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)modifyRouteTableRulesAsyncWithRequest:(VpcModifyRouteTableRulesRequest*) modifyRouteTableRulesRequest
                       completionHandler:(void(^)(int statusCode,VpcModifyRouteTableRulesResponse* _Nullable modifyRouteTableRulesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcModifyRouteTableRulesExecutor* excutor = [[VpcModifyRouteTableRulesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:modifyRouteTableRulesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyRouteTableRulesResponse* response = [[VpcModifyRouteTableRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
addRouteTableRules sync request
@param addRouteTableRulesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `addRouteTableRulesResponse` the request response data model
*/
-(NSDictionary*) addRouteTableRulesSyncWithRequest:(VpcAddRouteTableRulesRequest*) addRouteTableRulesRequest
{
VpcAddRouteTableRulesExecutor* excutor = [[VpcAddRouteTableRulesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:addRouteTableRulesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAddRouteTableRulesResponse* response = [[VpcAddRouteTableRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"addRouteTableRulesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)addRouteTableRulesAsyncWithRequest:(VpcAddRouteTableRulesRequest*) addRouteTableRulesRequest
                       completionHandler:(void(^)(int statusCode,VpcAddRouteTableRulesResponse* _Nullable addRouteTableRulesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcAddRouteTableRulesExecutor* excutor = [[VpcAddRouteTableRulesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:addRouteTableRulesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAddRouteTableRulesResponse* response = [[VpcAddRouteTableRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
modifyRouteTable sync request
@param modifyRouteTableRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `modifyRouteTableResponse` the request response data model
*/
-(NSDictionary*) modifyRouteTableSyncWithRequest:(VpcModifyRouteTableRequest*) modifyRouteTableRequest
{
VpcModifyRouteTableExecutor* excutor = [[VpcModifyRouteTableExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:modifyRouteTableRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyRouteTableResponse* response = [[VpcModifyRouteTableResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"modifyRouteTableResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)modifyRouteTableAsyncWithRequest:(VpcModifyRouteTableRequest*) modifyRouteTableRequest
                       completionHandler:(void(^)(int statusCode,VpcModifyRouteTableResponse* _Nullable modifyRouteTableResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcModifyRouteTableExecutor* excutor = [[VpcModifyRouteTableExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:modifyRouteTableRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyRouteTableResponse* response = [[VpcModifyRouteTableResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
unassignSecondaryIps sync request
@param unassignSecondaryIpsRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `unassignSecondaryIpsResponse` the request response data model
*/
-(NSDictionary*) unassignSecondaryIpsSyncWithRequest:(VpcUnassignSecondaryIpsRequest*) unassignSecondaryIpsRequest
{
VpcUnassignSecondaryIpsExecutor* excutor = [[VpcUnassignSecondaryIpsExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:unassignSecondaryIpsRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcUnassignSecondaryIpsResponse* response = [[VpcUnassignSecondaryIpsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"unassignSecondaryIpsResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)unassignSecondaryIpsAsyncWithRequest:(VpcUnassignSecondaryIpsRequest*) unassignSecondaryIpsRequest
                       completionHandler:(void(^)(int statusCode,VpcUnassignSecondaryIpsResponse* _Nullable unassignSecondaryIpsResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcUnassignSecondaryIpsExecutor* excutor = [[VpcUnassignSecondaryIpsExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:unassignSecondaryIpsRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcUnassignSecondaryIpsResponse* response = [[VpcUnassignSecondaryIpsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeElasticIp sync request
@param describeElasticIpRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeElasticIpResponse` the request response data model
*/
-(NSDictionary*) describeElasticIpSyncWithRequest:(VpcDescribeElasticIpRequest*) describeElasticIpRequest
{
VpcDescribeElasticIpExecutor* excutor = [[VpcDescribeElasticIpExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeElasticIpRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeElasticIpResponse* response = [[VpcDescribeElasticIpResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeElasticIpResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeElasticIpAsyncWithRequest:(VpcDescribeElasticIpRequest*) describeElasticIpRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeElasticIpResponse* _Nullable describeElasticIpResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeElasticIpExecutor* excutor = [[VpcDescribeElasticIpExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeElasticIpRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeElasticIpResponse* response = [[VpcDescribeElasticIpResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
associateElasticIp sync request
@param associateElasticIpRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `associateElasticIpResponse` the request response data model
*/
-(NSDictionary*) associateElasticIpSyncWithRequest:(VpcAssociateElasticIpRequest*) associateElasticIpRequest
{
VpcAssociateElasticIpExecutor* excutor = [[VpcAssociateElasticIpExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:associateElasticIpRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAssociateElasticIpResponse* response = [[VpcAssociateElasticIpResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"associateElasticIpResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)associateElasticIpAsyncWithRequest:(VpcAssociateElasticIpRequest*) associateElasticIpRequest
                       completionHandler:(void(^)(int statusCode,VpcAssociateElasticIpResponse* _Nullable associateElasticIpResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcAssociateElasticIpExecutor* excutor = [[VpcAssociateElasticIpExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:associateElasticIpRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAssociateElasticIpResponse* response = [[VpcAssociateElasticIpResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
disassociateRouteTable sync request
@param disassociateRouteTableRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `disassociateRouteTableResponse` the request response data model
*/
-(NSDictionary*) disassociateRouteTableSyncWithRequest:(VpcDisassociateRouteTableRequest*) disassociateRouteTableRequest
{
VpcDisassociateRouteTableExecutor* excutor = [[VpcDisassociateRouteTableExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:disassociateRouteTableRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDisassociateRouteTableResponse* response = [[VpcDisassociateRouteTableResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"disassociateRouteTableResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)disassociateRouteTableAsyncWithRequest:(VpcDisassociateRouteTableRequest*) disassociateRouteTableRequest
                       completionHandler:(void(^)(int statusCode,VpcDisassociateRouteTableResponse* _Nullable disassociateRouteTableResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDisassociateRouteTableExecutor* excutor = [[VpcDisassociateRouteTableExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:disassociateRouteTableRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDisassociateRouteTableResponse* response = [[VpcDisassociateRouteTableResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
modifyVpc sync request
@param modifyVpcRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `modifyVpcResponse` the request response data model
*/
-(NSDictionary*) modifyVpcSyncWithRequest:(VpcModifyVpcRequest*) modifyVpcRequest
{
VpcModifyVpcExecutor* excutor = [[VpcModifyVpcExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:modifyVpcRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyVpcResponse* response = [[VpcModifyVpcResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"modifyVpcResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)modifyVpcAsyncWithRequest:(VpcModifyVpcRequest*) modifyVpcRequest
                       completionHandler:(void(^)(int statusCode,VpcModifyVpcResponse* _Nullable modifyVpcResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcModifyVpcExecutor* excutor = [[VpcModifyVpcExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:modifyVpcRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifyVpcResponse* response = [[VpcModifyVpcResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
associateNetworkAcl sync request
@param associateNetworkAclRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `associateNetworkAclResponse` the request response data model
*/
-(NSDictionary*) associateNetworkAclSyncWithRequest:(VpcAssociateNetworkAclRequest*) associateNetworkAclRequest
{
VpcAssociateNetworkAclExecutor* excutor = [[VpcAssociateNetworkAclExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:associateNetworkAclRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAssociateNetworkAclResponse* response = [[VpcAssociateNetworkAclResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"associateNetworkAclResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)associateNetworkAclAsyncWithRequest:(VpcAssociateNetworkAclRequest*) associateNetworkAclRequest
                       completionHandler:(void(^)(int statusCode,VpcAssociateNetworkAclResponse* _Nullable associateNetworkAclResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcAssociateNetworkAclExecutor* excutor = [[VpcAssociateNetworkAclExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:associateNetworkAclRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAssociateNetworkAclResponse* response = [[VpcAssociateNetworkAclResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
modifySubnet sync request
@param modifySubnetRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `modifySubnetResponse` the request response data model
*/
-(NSDictionary*) modifySubnetSyncWithRequest:(VpcModifySubnetRequest*) modifySubnetRequest
{
VpcModifySubnetExecutor* excutor = [[VpcModifySubnetExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:modifySubnetRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifySubnetResponse* response = [[VpcModifySubnetResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"modifySubnetResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)modifySubnetAsyncWithRequest:(VpcModifySubnetRequest*) modifySubnetRequest
                       completionHandler:(void(^)(int statusCode,VpcModifySubnetResponse* _Nullable modifySubnetResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcModifySubnetExecutor* excutor = [[VpcModifySubnetExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:modifySubnetRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcModifySubnetResponse* response = [[VpcModifySubnetResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createElasticIps sync request
@param createElasticIpsRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createElasticIpsResponse` the request response data model
*/
-(NSDictionary*) createElasticIpsSyncWithRequest:(VpcCreateElasticIpsRequest*) createElasticIpsRequest
{
VpcCreateElasticIpsExecutor* excutor = [[VpcCreateElasticIpsExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createElasticIpsRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateElasticIpsResponse* response = [[VpcCreateElasticIpsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createElasticIpsResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createElasticIpsAsyncWithRequest:(VpcCreateElasticIpsRequest*) createElasticIpsRequest
                       completionHandler:(void(^)(int statusCode,VpcCreateElasticIpsResponse* _Nullable createElasticIpsResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcCreateElasticIpsExecutor* excutor = [[VpcCreateElasticIpsExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createElasticIpsRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcCreateElasticIpsResponse* response = [[VpcCreateElasticIpsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteNetworkInterface sync request
@param deleteNetworkInterfaceRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteNetworkInterfaceResponse` the request response data model
*/
-(NSDictionary*) deleteNetworkInterfaceSyncWithRequest:(VpcDeleteNetworkInterfaceRequest*) deleteNetworkInterfaceRequest
{
VpcDeleteNetworkInterfaceExecutor* excutor = [[VpcDeleteNetworkInterfaceExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteNetworkInterfaceRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteNetworkInterfaceResponse* response = [[VpcDeleteNetworkInterfaceResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteNetworkInterfaceResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteNetworkInterfaceAsyncWithRequest:(VpcDeleteNetworkInterfaceRequest*) deleteNetworkInterfaceRequest
                       completionHandler:(void(^)(int statusCode,VpcDeleteNetworkInterfaceResponse* _Nullable deleteNetworkInterfaceResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDeleteNetworkInterfaceExecutor* excutor = [[VpcDeleteNetworkInterfaceExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteNetworkInterfaceRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDeleteNetworkInterfaceResponse* response = [[VpcDeleteNetworkInterfaceResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
describeNetworkAcl sync request
@param describeNetworkAclRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `describeNetworkAclResponse` the request response data model
*/
-(NSDictionary*) describeNetworkAclSyncWithRequest:(VpcDescribeNetworkAclRequest*) describeNetworkAclRequest
{
VpcDescribeNetworkAclExecutor* excutor = [[VpcDescribeNetworkAclExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:describeNetworkAclRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeNetworkAclResponse* response = [[VpcDescribeNetworkAclResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"describeNetworkAclResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)describeNetworkAclAsyncWithRequest:(VpcDescribeNetworkAclRequest*) describeNetworkAclRequest
                       completionHandler:(void(^)(int statusCode,VpcDescribeNetworkAclResponse* _Nullable describeNetworkAclResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcDescribeNetworkAclExecutor* excutor = [[VpcDescribeNetworkAclExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:describeNetworkAclRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcDescribeNetworkAclResponse* response = [[VpcDescribeNetworkAclResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
addNetworkAclRules sync request
@param addNetworkAclRulesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `addNetworkAclRulesResponse` the request response data model
*/
-(NSDictionary*) addNetworkAclRulesSyncWithRequest:(VpcAddNetworkAclRulesRequest*) addNetworkAclRulesRequest
{
VpcAddNetworkAclRulesExecutor* excutor = [[VpcAddNetworkAclRulesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:addNetworkAclRulesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAddNetworkAclRulesResponse* response = [[VpcAddNetworkAclRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"addNetworkAclRulesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)addNetworkAclRulesAsyncWithRequest:(VpcAddNetworkAclRulesRequest*) addNetworkAclRulesRequest
                       completionHandler:(void(^)(int statusCode,VpcAddNetworkAclRulesResponse* _Nullable addNetworkAclRulesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VpcAddNetworkAclRulesExecutor* excutor = [[VpcAddNetworkAclRulesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:addNetworkAclRulesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VpcAddNetworkAclRulesResponse* response = [[VpcAddNetworkAclRulesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}


 /**
 vpc common sync request
 @param  jdcloudDataRequest request param
 @return key `statusCode` http request status code type is int
             `dataResult` the http request response data  type is NSData
             `requestError` the request error type is NSError
 */
 -(NSDictionary*) vpcCommonSyncWithRequest:(JDCloudDataRequest*) jdcloudDataRequest
                                                   url:(NSString*) url
                                                method:(NSString*) method{
    CommonExecutor* excutor = [[CommonExecutor alloc] initWithJDCloudClient:self url:url method:method];
    NSDictionary* responseResult = [excutor executeDataSync:jdcloudDataRequest];
    return responseResult;
}

-(void)vpcCommonAsyncWithRequest:(JDCloudDataRequest*) jdcloudDataRequest
                                         url:(NSString*) url
                                      method:(NSString*) method
                           completionHandler:(void(^)(int statusCode, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
     CommonExecutor* excutor = [[CommonExecutor alloc] initWithJDCloudClient:self url:url method:method];
    
    [excutor executeDataAsync:jdcloudDataRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        completionHandler(statusCode,responseData,error);
    }];
} 

@end
